{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-09T11:05:32.227183Z",
     "start_time": "2025-01-09T11:05:20.293027Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": "### 特征中含有字符串的时候（当成类别），如何做特征抽取",
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=False)  # 把sparse改为True是稀疏矩阵\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:06:40.768400Z",
     "start_time": "2025-01-09T11:06:40.757090Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.   1.   0. 100.]\n",
      " [  1.   0.   0.  60.]\n",
      " [  0.   0.   1.  30.]]\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())#默认单个字母的单词被去掉了\n",
    "    print('-' * 50)\n",
    "    # print(res)\n",
    "    print('-' * 50)\n",
    "    # print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:16:14.453321Z",
     "start_time": "2025-01-09T11:16:14.442299Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:17:56.934522Z",
     "start_time": "2025-01-09T11:17:56.923097Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "source": "###  掌握如何对中文进行分词",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:27:57.987120Z",
     "start_time": "2025-01-09T11:27:57.970566Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "markdown",
   "source": [
    "###  tf-idf\n",
    "词频 - 逆文档频率，是一种在信息检索与文本挖掘中常用的加权技术，用于评估一个词对于一个文档集或语料库中的某份文档的重要程度"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)#为true是确保计算idf时不出现0分母\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:34:13.972188Z",
     "start_time": "2025-01-09T11:34:13.867598Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "markdown",
   "source": "###  特征处理，不同的特征拉到到同一个量纲",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理，数据量更小，更精确\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)#进行归一化之后的数据。那个公式。每一列看最小值最大值代入。归一化后所有数据都在0-1之间。\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])#这个out并不是重新计算了最大最小值代入公式进行归一，而是沿用data的最值进行归一。（沿用训练集）\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:35:20.370210Z",
     "start_time": "2025-01-09T11:35:20.323605Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "-1.9666666666666666"
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T01:56:23.103848700Z",
     "start_time": "2024-07-11T01:56:23.052804200Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，指均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:53:00.439529Z",
     "start_time": "2025-01-09T11:53:00.430335Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:53:31.794475Z",
     "start_time": "2025-01-09T11:53:31.783587Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T11:53:33.203214Z",
     "start_time": "2025-01-09T11:53:33.194303Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T11:53:33.357551Z",
     "start_time": "2025-01-09T11:53:33.349220Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 26
  },
  {
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T11:53:35.549662Z",
     "start_time": "2025-01-09T11:53:35.539409Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 27
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T06:17:18.212483Z",
     "start_time": "2025-01-09T06:17:18.208598Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.068779614944516"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": "### 缺失值处理\n",
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:54:14.563611Z",
     "start_time": "2025-01-09T11:54:14.498364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 28
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "3.6666666666666665"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:22:34.367453500Z",
     "start_time": "2024-07-11T02:22:34.322497700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "nan"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:23:44.133095700Z",
     "start_time": "2024-07-11T02:23:44.114673600Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##  降维\n",
    "### 降维就是特征数变少\n",
    "### 降维可以提高模型训练速度（特征变少）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:55:24.002359Z",
     "start_time": "2025-01-09T11:55:23.971646Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 29
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.90)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)#表示每个主成分所解释的方差占总方差的比例\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:57:58.877949Z",
     "start_time": "2025-01-09T11:57:58.862160Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 32
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "0.7499999999999999"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T03:08:17.259124100Z",
     "start_time": "2024-07-11T03:08:17.248038900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #均匀随机数\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")#绿色，标签\n",
    "plt.legend(loc=\"upper left\")#图例位置\n",
    "plt.grid()#网格\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T11:59:48.873813Z",
     "start_time": "2025-01-09T11:59:45.333161Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 33
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
